home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Flex-CW 2.5.1 / main.c < prev    next >
C/C++ Source or Header  |  1995-10-14  |  29KB  |  1,196 lines
  1. /* flex - tool to generate fast lexical analyzers */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  *
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. #ifndef lint
  30. char copyright[] =
  31. "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
  32.  All rights reserved.\n";
  33. #endif /* not lint */
  34.  
  35. /* $Header: /home/daffy/u0/vern/flex/RCS/main.c,v 2.60 95/03/21 13:44:34 vern Exp $ */
  36.  
  37.  
  38. #include "flexdef.h"
  39. #include "version.h"
  40.  
  41. static char flex_version[] = FLEX_VERSION;
  42.  
  43.  
  44. /* declare functions that have forward references */
  45.  
  46. void flexinit PROTO((int, char**));
  47. void readin PROTO((void));
  48. void set_up_initial_allocations PROTO((void));
  49.  
  50. #ifdef NEED_ARGV_FIXUP
  51. extern void argv_fixup PROTO((int *, char ***));
  52. #endif
  53.  
  54.  
  55. /* these globals are all defined and commented in flexdef.h */
  56. int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
  57. int interactive, caseins, lex_compat, do_yylineno, useecs, fulltbl, usemecs;
  58. int fullspd, gen_line_dirs, performance_report, backing_up_report;
  59. int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap, csize;
  60. int yymore_used, reject, real_reject, continued_action, in_rule;
  61. int yymore_really_used, reject_really_used;
  62. int datapos, dataline, linenum, out_linenum;
  63. FILE *skelfile = NULL;
  64. int skel_ind = 0;
  65. char *action_array;
  66. int action_size, defs1_offset, prolog_offset, action_offset, action_index;
  67. char *infilename = NULL, *outfilename = NULL;
  68. int did_outfilename;
  69. char *prefix, *yyclass;
  70. int do_stdinit, use_stdout;
  71. int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
  72. int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
  73. int current_mns, current_max_rules;
  74. int num_rules, num_eof_rules, default_rule, lastnfa;
  75. int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
  76. int *accptnum, *assoc_rule, *state_type;
  77. int *rule_type, *rule_linenum, *rule_useful;
  78. int current_state_type;
  79. int variable_trailing_context_rules;
  80. int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
  81. int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
  82. int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
  83. int tecbck[CSIZE + 1];
  84. int lastsc, *scset, *scbol, *scxclu, *sceof;
  85. int current_max_scs;
  86. char **scname;
  87. int current_max_dfa_size, current_max_xpairs;
  88. int current_max_template_xpairs, current_max_dfas;
  89. int lastdfa, *nxt, *chk, *tnxt;
  90. int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
  91. union dfaacc_union *dfaacc;
  92. int *accsiz, *dhash, numas;
  93. int numsnpairs, jambase, jamstate;
  94. int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
  95. int current_maxccls, current_max_ccl_tbl_size;
  96. Char *ccltbl;
  97. char nmstr[MAXLINE];
  98. int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
  99. int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
  100. int num_backing_up, bol_needed;
  101. FILE *backing_up_file;
  102. int end_of_buffer_state;
  103. char **input_files;
  104. int num_input_files;
  105.  
  106. /* Make sure program_name is initialized so we don't crash if writing
  107.  * out an error message before getting the program name from argv[0].
  108.  */
  109. char *program_name = "flex";
  110.  
  111. #ifndef SHORT_FILE_NAMES
  112. static char *outfile_template = "lex.%s.%s";
  113. static char *backing_name = "lex.backup";
  114. #else
  115. static char *outfile_template = "lex%s.%s";
  116. static char *backing_name = "lex.bck";
  117. #endif
  118.  
  119. #ifdef THINK_C
  120. #include <console.h>
  121. #endif
  122.  
  123. #ifdef __MWERKS__
  124. #include "GIJO.h"
  125. #endif
  126.  
  127. #ifdef MS_DOS
  128. extern unsigned _stklen = 16384;
  129. #endif
  130.  
  131. static char outfile_path[MAXLINE];
  132. static int outfile_created = 0;
  133. static char *skelname = NULL;
  134.  
  135.  
  136. #ifdef __GIJO__
  137. short main(short argc, char **argv)
  138. #else
  139. int main( argc, argv )
  140. int argc;
  141. char **argv;
  142. #endif
  143.     {
  144.     int i;
  145.  
  146. #ifdef THINK_C
  147.     argc = ccommand( &argv );
  148. #endif
  149. #ifdef NEED_ARGV_FIXUP
  150.     argv_fixup( &argc, &argv );
  151. #endif
  152.  
  153.     flexinit( argc, argv );
  154.  
  155.     readin();
  156.  
  157.     ntod();
  158.  
  159.     for ( i = 1; i <= num_rules; ++i )
  160.         if ( ! rule_useful[i] && i != default_rule )
  161.             line_warning( _( "rule cannot be matched" ),
  162.                     rule_linenum[i] );
  163.  
  164.     if ( spprdflt && ! reject && rule_useful[default_rule] )
  165.         line_warning(
  166.             _( "-s option given but default rule can be matched" ),
  167.             rule_linenum[default_rule] );
  168.  
  169.     /* Generate the C state transition tables from the DFA. */
  170.     make_tables();
  171.  
  172.     /* Note, flexend does not return.  It exits with its argument
  173.      * as status.
  174.      */
  175.     flexend( 0 );
  176.  
  177.     return 0;    /* keep compilers/lint happy */
  178.     }
  179.  
  180.  
  181. /* check_options - check user-specified options */
  182.  
  183. void check_options()
  184.     {
  185.     int i;
  186.  
  187.     if ( lex_compat )
  188.         {
  189.         if ( C_plus_plus )
  190.             flexerror( _( "Can't use -+ with -l option" ) );
  191.  
  192.         if ( fulltbl || fullspd )
  193.             flexerror( _( "Can't use -f or -F with -l option" ) );
  194.  
  195.         /* Don't rely on detecting use of yymore() and REJECT,
  196.          * just assume they'll be used.
  197.          */
  198.         yymore_really_used = reject_really_used = true;
  199.  
  200.         yytext_is_array = true;
  201.         do_yylineno = true;
  202.         use_read = false;
  203.         }
  204.  
  205.     if ( do_yylineno )
  206.         /* This should really be "maintain_backup_tables = true" */
  207.         reject_really_used = true;
  208.  
  209.     if ( csize == unspecified )
  210.         {
  211.         if ( (fulltbl || fullspd) && ! useecs )
  212.             csize = DEFAULT_CSIZE;
  213.         else
  214.             csize = CSIZE;
  215.         }
  216.  
  217.     if ( interactive == unspecified )
  218.         {
  219.         if ( fulltbl || fullspd )
  220.             interactive = false;
  221.         else
  222.             interactive = true;
  223.         }
  224.  
  225.     if ( fulltbl || fullspd )
  226.         {
  227.         if ( usemecs )
  228.             flexerror(
  229.             _( "-Cf/-CF and -Cm don't make sense together" ) );
  230.  
  231.         if ( interactive )
  232.             flexerror( _( "-Cf/-CF and -I are incompatible" ) );
  233.  
  234.         if ( lex_compat )
  235.             flexerror(
  236.         _( "-Cf/-CF are incompatible with lex-compatibility mode" ) );
  237.  
  238.         if ( do_yylineno )
  239.             flexerror(
  240.             _( "-Cf/-CF and %option yylineno are incompatible" ) );
  241.  
  242.         if ( fulltbl && fullspd )
  243.             flexerror( _( "-Cf and -CF are mutually exclusive" ) );
  244.         }
  245.  
  246.     if ( C_plus_plus && fullspd )
  247.         flexerror( _( "Can't use -+ with -CF option" ) );
  248.  
  249.     if ( C_plus_plus && yytext_is_array )
  250.         {
  251.         warn( _( "%array incompatible with -+ option" ) );
  252.         yytext_is_array = false;
  253.         }
  254.  
  255.     if ( useecs )
  256.         { /* Set up doubly-linked equivalence classes. */
  257.  
  258.         /* We loop all the way up to csize, since ecgroup[csize] is
  259.          * the position used for NUL characters.
  260.          */
  261.         ecgroup[1] = NIL;
  262.  
  263.         for ( i = 2; i <= csize; ++i )
  264.             {
  265.             ecgroup[i] = i - 1;
  266.             nextecm[i - 1] = i;
  267.             }
  268.  
  269.         nextecm[csize] = NIL;
  270.         }
  271.  
  272.     else
  273.         {
  274.         /* Put everything in its own equivalence class. */
  275.         for ( i = 1; i <= csize; ++i )
  276.             {
  277.             ecgroup[i] = i;
  278.             nextecm[i] = BAD_SUBSCRIPT;    /* to catch errors */
  279.             }
  280.         }
  281.  
  282.     if ( ! use_stdout )
  283.         {
  284.         FILE *prev_stdout;
  285.  
  286.         if ( ! did_outfilename )
  287.             {
  288.             char *suffix;
  289.  
  290.             if ( C_plus_plus )
  291.                 suffix = "cc";
  292.             else
  293.                 suffix = "c";
  294.  
  295.             sprintf( outfile_path, outfile_template,
  296.                 prefix, suffix );
  297.  
  298.             outfilename = outfile_path;
  299.             }
  300.  
  301.         prev_stdout = freopen( outfilename, "w", stdout );
  302.  
  303.         if ( prev_stdout == NULL )
  304.             lerrsf( _( "could not create %s" ), outfilename );
  305.  
  306.         outfile_created = 1;
  307.         }
  308.  
  309.     if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
  310.         lerrsf( _( "can't open skeleton file %s" ), skelname );
  311.  
  312.     if ( strcmp( prefix, "yy" ) )
  313.         {
  314. #define GEN_PREFIX(name) out_str3( "#define yy%s %s%s\n", name, prefix, name )
  315.         if ( C_plus_plus )
  316.             GEN_PREFIX( "FlexLexer" );
  317.         else
  318.             {
  319.             GEN_PREFIX( "_create_buffer" );
  320.             GEN_PREFIX( "_delete_buffer" );
  321.             GEN_PREFIX( "_scan_buffer" );
  322.             GEN_PREFIX( "_scan_string" );
  323.             GEN_PREFIX( "_scan_bytes" );
  324.             GEN_PREFIX( "_flex_debug" );
  325.             GEN_PREFIX( "_init_buffer" );
  326.             GEN_PREFIX( "_flush_buffer" );
  327.             GEN_PREFIX( "_load_buffer_state" );
  328.             GEN_PREFIX( "_switch_to_buffer" );
  329.             GEN_PREFIX( "in" );
  330.             GEN_PREFIX( "leng" );
  331.             GEN_PREFIX( "lex" );
  332.             GEN_PREFIX( "out" );
  333.             GEN_PREFIX( "restart" );
  334.             GEN_PREFIX( "text" );
  335.  
  336.             if ( do_yylineno )
  337.                 GEN_PREFIX( "lineno" );
  338.             }
  339.  
  340.         if ( do_yywrap )
  341.             GEN_PREFIX( "wrap" );
  342.  
  343.         outn( "" );
  344.         }
  345.  
  346.     if ( did_outfilename )
  347.         line_directive_out( stdout, 0 );
  348.  
  349.     skelout();
  350.     }
  351.  
  352.  
  353. /* flexend - terminate flex
  354.  *
  355.  * note
  356.  *    This routine does not return.
  357.  */
  358.  
  359. void flexend( exit_status )
  360. int exit_status;
  361.  
  362.     {
  363.     int tblsiz;
  364.     int unlink();
  365.  
  366.     if ( skelfile != NULL )
  367.         {
  368.         if ( ferror( skelfile ) )
  369.             lerrsf( _( "input error reading skeleton file %s" ),
  370.                 skelname );
  371.  
  372.         else if ( fclose( skelfile ) )
  373.             lerrsf( _( "error closing skeleton file %s" ),
  374.                 skelname );
  375.         }
  376.  
  377.     if ( exit_status != 0 && outfile_created )
  378.         {
  379.         if ( ferror( stdout ) )
  380.             lerrsf( _( "error writing output file %s" ),
  381.                 outfilename );
  382.  
  383.         else if ( fclose( stdout ) )
  384.             lerrsf( _( "error closing output file %s" ),
  385.                 outfilename );
  386.  
  387.         else if ( unlink( outfilename ) )
  388.             lerrsf( _( "error deleting output file %s" ),
  389.                 outfilename );
  390.         }
  391.  
  392.     if ( backing_up_report && backing_up_file )
  393.         {
  394.         if ( num_backing_up == 0 )
  395.             fprintf( backing_up_file, _( "No backing up.\n" ) );
  396.         else if ( fullspd || fulltbl )
  397.             fprintf( backing_up_file,
  398.                 _( "%d backing up (non-accepting) states.\n" ),
  399.                 num_backing_up );
  400.         else
  401.             fprintf( backing_up_file,
  402.                 _( "Compressed tables always back up.\n" ) );
  403.  
  404.         if ( ferror( backing_up_file ) )
  405.             lerrsf( _( "error writing backup file %s" ),
  406.                 backing_name );
  407.  
  408.         else if ( fclose( backing_up_file ) )
  409.             lerrsf( _( "error closing backup file %s" ),
  410.                 backing_name );
  411.         }
  412.  
  413.     if ( printstats )
  414.         {
  415.         fprintf( stderr, _( "%s version %s usage statistics:\n" ),
  416.             program_name, flex_version );
  417.  
  418.         fprintf( stderr, _( "  scanner options: -" ) );
  419.  
  420.         if ( C_plus_plus )
  421.             putc( '+', stderr );
  422.         if ( backing_up_report )
  423.             putc( 'b', stderr );
  424.         if ( ddebug )
  425.             putc( 'd', stderr );
  426.         if ( caseins )
  427.             putc( 'i', stderr );
  428.         if ( lex_compat )
  429.             putc( 'l', stderr );
  430.         if ( performance_report > 0 )
  431.             putc( 'p', stderr );
  432.         if ( performance_report > 1 )
  433.             putc( 'p', stderr );
  434.         if ( spprdflt )
  435.             putc( 's', stderr );
  436.         if ( use_stdout )
  437.             putc( 't', stderr );
  438.         if ( printstats )
  439.             putc( 'v', stderr );    /* always true! */
  440.         if ( nowarn )
  441.             putc( 'w', stderr );
  442.         if ( interactive == false )
  443.             putc( 'B', stderr );
  444.         if ( interactive == true )
  445.             putc( 'I', stderr );
  446.         if ( ! gen_line_dirs )
  447.             putc( 'L', stderr );
  448.         if ( trace )
  449.             putc( 'T', stderr );
  450.  
  451.         if ( csize == unspecified )
  452.             /* We encountered an error fairly early on, so csize
  453.              * never got specified.  Define it now, to prevent
  454.              * bogus table sizes being written out below.
  455.              */
  456.             csize = 256;
  457.  
  458.         if ( csize == 128 )
  459.             putc( '7', stderr );
  460.         else
  461.             putc( '8', stderr );
  462.  
  463.         fprintf( stderr, " -C" );
  464.  
  465.         if ( long_align )
  466.             putc( 'a', stderr );
  467.         if ( fulltbl )
  468.             putc( 'f', stderr );
  469.         if ( fullspd )
  470.             putc( 'F', stderr );
  471.         if ( useecs )
  472.             putc( 'e', stderr );
  473.         if ( usemecs )
  474.             putc( 'm', stderr );
  475.         if ( use_read )
  476.             putc( 'r', stderr );
  477.  
  478.         if ( did_outfilename )
  479.             fprintf( stderr, " -o%s", outfilename );
  480.  
  481.         if ( skelname )
  482.             fprintf( stderr, " -S%s", skelname );
  483.  
  484.         if ( strcmp( prefix, "yy" ) )
  485.             fprintf( stderr, " -P%s", prefix );
  486.  
  487.         putc( '\n', stderr );
  488.  
  489.         fprintf( stderr, _( "  %d/%d NFA states\n" ),
  490.             lastnfa, current_mns );
  491.         fprintf( stderr, _( "  %d/%d DFA states (%d words)\n" ),
  492.             lastdfa, current_max_dfas, totnst );
  493.         fprintf( stderr, _( "  %d rules\n" ),
  494.         num_rules + num_eof_rules - 1 /* - 1 for def. rule */ );
  495.  
  496.         if ( num_backing_up == 0 )
  497.             fprintf( stderr, _( "  No backing up\n" ) );
  498.         else if ( fullspd || fulltbl )
  499.             fprintf( stderr,
  500.             _( "  %d backing-up (non-accepting) states\n" ),
  501.                 num_backing_up );
  502.         else
  503.             fprintf( stderr,
  504.                 _( "  Compressed tables always back-up\n" ) );
  505.  
  506.         if ( bol_needed )
  507.             fprintf( stderr,
  508.                 _( "  Beginning-of-line patterns used\n" ) );
  509.  
  510.         fprintf( stderr, _( "  %d/%d start conditions\n" ), lastsc,
  511.             current_max_scs );
  512.         fprintf( stderr,
  513.             _( "  %d epsilon states, %d double epsilon states\n" ),
  514.             numeps, eps2 );
  515.  
  516.         if ( lastccl == 0 )
  517.             fprintf( stderr, _( "  no character classes\n" ) );
  518.         else
  519.             fprintf( stderr,
  520. _( "  %d/%d character classes needed %d/%d words of storage, %d reused\n" ),
  521.                 lastccl, current_maxccls,
  522.                 cclmap[lastccl] + ccllen[lastccl],
  523.                 current_max_ccl_tbl_size, cclreuse );
  524.  
  525.         fprintf( stderr, _( "  %d state/nextstate pairs created\n" ),
  526.             numsnpairs );
  527.         fprintf( stderr, _( "  %d/%d unique/duplicate transitions\n" ),
  528.             numuniq, numdup );
  529.  
  530.         if ( fulltbl )
  531.             {
  532.             tblsiz = lastdfa * numecs;
  533.             fprintf( stderr, _( "  %d table entries\n" ), tblsiz );
  534.             }
  535.  
  536.         else
  537.             {
  538.             tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
  539.  
  540.             fprintf( stderr,
  541.                 _( "  %d/%d base-def entries created\n" ),
  542.                 lastdfa + numtemps, current_max_dfas );
  543.             fprintf( stderr,
  544.             _( "  %d/%d (peak %d) nxt-chk entries created\n" ),
  545.                 tblend, current_max_xpairs, peakpairs );
  546.             fprintf( stderr,
  547.         _( "  %d/%d (peak %d) template nxt-chk entries created\n" ),
  548.                 numtemps * nummecs,
  549.                 current_max_template_xpairs,
  550.                 numtemps * numecs );
  551.             fprintf( stderr, _( "  %d empty table entries\n" ),
  552.                 nummt );
  553.             fprintf( stderr, _( "  %d protos created\n" ),
  554.                 numprots );
  555.             fprintf( stderr,
  556.                 _( "  %d templates created, %d uses\n" ),
  557.                 numtemps, tmpuses );
  558.             }
  559.  
  560.         if ( useecs )
  561.             {
  562.             tblsiz = tblsiz + csize;
  563.             fprintf( stderr,
  564.                 _( "  %d/%d equivalence classes created\n" ),
  565.                 numecs, csize );
  566.             }
  567.  
  568.         if ( usemecs )
  569.             {
  570.             tblsiz = tblsiz + numecs;
  571.             fprintf( stderr,
  572.             _( "  %d/%d meta-equivalence classes created\n" ),
  573.                 nummecs, csize );
  574.             }
  575.  
  576.         fprintf( stderr,
  577.         _( "  %d (%d saved) hash collisions, %d DFAs equal\n" ),
  578.             hshcol, hshsave, dfaeql );
  579.         fprintf( stderr, _( "  %d sets of reallocations needed\n" ),
  580.             num_reallocs );
  581.         fprintf( stderr, _( "  %d total table entries needed\n" ),
  582.             tblsiz );
  583.         }
  584.  
  585.     exit( exit_status );
  586.     }
  587.  
  588.  
  589. /* flexinit - initialize flex */
  590.  
  591. void flexinit( argc, argv )
  592. int argc;
  593. char **argv;
  594.     {
  595.     int i, sawcmpflag;
  596.     char *arg, *mktemp();
  597.  
  598.     printstats = syntaxerror = trace = spprdflt = caseins = false;
  599.     lex_compat = C_plus_plus = backing_up_report = ddebug = fulltbl = false;
  600.     fullspd = long_align = nowarn = yymore_used = continued_action = false;
  601.     do_yylineno = yytext_is_array = in_rule = reject = false;
  602.     yymore_really_used = reject_really_used = unspecified;
  603.     interactive = csize = unspecified;
  604.     do_yywrap = gen_line_dirs = usemecs = useecs = do_stdinit = true;
  605.     performance_report = 0;
  606.     did_outfilename = 0;
  607.     prefix = "yy";
  608.     yyclass = 0;
  609.     use_read = use_stdout = false;
  610.  
  611.     sawcmpflag = false;
  612.  
  613.     /* Initialize dynamic array for holding the rule actions. */
  614.     action_size = 2048;    /* default size of action array in bytes */
  615.     action_array = allocate_character_array( action_size );
  616.     defs1_offset = prolog_offset = action_offset = action_index = 0;
  617.     action_array[0] = '\0';
  618.  
  619.     program_name = argv[0];
  620.  
  621.     if ( program_name[0] != '\0' &&
  622.          program_name[strlen( program_name ) - 1] == '+' )
  623.         C_plus_plus = true;
  624.  
  625.     /* read flags */
  626.     for ( --argc, ++argv; argc ; --argc, ++argv )
  627.         {
  628.         arg = argv[0];
  629.  
  630.         if ( arg[0] != '-' || arg[1] == '\0' )
  631.             break;
  632.  
  633.         if ( arg[1] == '-' )
  634.             { /* --option */
  635.             if ( ! strcmp( arg, "--help" ) )
  636.                 arg = "-h";
  637.  
  638.             else if ( ! strcmp( arg, "--version" ) )
  639.                 arg = "-V";
  640.             }
  641.  
  642.         for ( i = 1; arg[i] != '\0'; ++i )
  643.             switch ( arg[i] )
  644.                 {
  645.                 case '+':
  646.                     C_plus_plus = true;
  647.                     break;
  648.  
  649. #ifdef __GIJO__
  650.                 /* we add these as an option type because GIJO cannot insert */
  651.                 /* into the -C switch easily (without duplicating eight radio */
  652.                 /* buttons which is quite painful. */
  653.                 case 'A':
  654.                     long_align = true;
  655.                     break;
  656.                 case 'R':
  657.                     use_read = true;
  658.                     break;
  659. #endif
  660.                 case 'B':
  661.                     interactive = false;
  662.                     break;
  663.  
  664.                 case 'b':
  665.                     backing_up_report = true;
  666.                     break;
  667.  
  668.                 case 'c':
  669.                     break;
  670.  
  671.                 case 'C':
  672.                     if ( i != 1 )
  673.                         flexerror(
  674.                 _( "-C flag must be given separately" ) );
  675.  
  676.                     if ( ! sawcmpflag )
  677.                         {
  678.                         useecs = false;
  679.                         usemecs = false;
  680.                         fulltbl = false;
  681.                         sawcmpflag = true;
  682.                         }
  683.  
  684.                     for ( ++i; arg[i] != '\0'; ++i )
  685.                         switch ( arg[i] )
  686.                             {
  687.                             case 'a':
  688.                                 long_align =
  689.                                     true;
  690.                                 break;
  691.  
  692.                             case 'e':
  693.                                 useecs = true;
  694.                                 break;
  695.  
  696.                             case 'F':
  697.                                 fullspd = true;
  698.                                 break;
  699.  
  700.                             case 'f':
  701.                                 fulltbl = true;
  702.                                 break;
  703.  
  704.                             case 'm':
  705.                                 usemecs = true;
  706.                                 break;
  707.  
  708.                             case 'r':
  709.                                 use_read = true;
  710.                                 break;
  711.  
  712.                             default:
  713.                                 lerrif(
  714.                         _( "unknown -C option '%c'" ),
  715.                                 (int) arg[i] );
  716.                                 break;
  717.                             }
  718.  
  719.                     goto get_next_arg;
  720.  
  721.                 case 'd':
  722.                     ddebug = true;
  723.                     break;
  724.  
  725.                 case 'f':
  726.                     useecs = usemecs = false;
  727.                     use_read = fulltbl = true;
  728.                     break;
  729.  
  730.                 case 'F':
  731.                     useecs = usemecs = false;
  732.                     use_read = fullspd = true;
  733.                     break;
  734.  
  735.                 case '?':
  736.                 case 'h':
  737.                     usage();
  738.                     exit( 0 );
  739.  
  740.                 case 'I':
  741.                     interactive = true;
  742.                     break;
  743.  
  744.                 case 'i':
  745.                     caseins = true;
  746.                     break;
  747.  
  748.                 case 'l':
  749.                     lex_compat = true;
  750.                     break;
  751.  
  752.                 case 'L':
  753.                     gen_line_dirs = false;
  754.                     break;
  755.  
  756.                 case 'n':
  757.                     /* Stupid do-nothing deprecated
  758.                      * option.
  759.                      */
  760.                     break;
  761.  
  762.                 case 'o':
  763.                     if ( i != 1 )
  764.                         flexerror(
  765.                 _( "-o flag must be given separately" ) );
  766.  
  767.                     outfilename = arg + i + 1;
  768.                     did_outfilename = 1;
  769.                     goto get_next_arg;
  770.  
  771.                 case 'P':
  772.                     if ( i != 1 )
  773.                         flexerror(
  774.                 _( "-P flag must be given separately" ) );
  775.  
  776.                     prefix = arg + i + 1;
  777.                     goto get_next_arg;
  778.  
  779.                 case 'p':
  780.                     ++performance_report;
  781.                     break;
  782.  
  783.                 case 'S':
  784.                     if ( i != 1 )
  785.                         flexerror(
  786.                 _( "-S flag must be given separately" ) );
  787.  
  788.                     skelname = arg + i + 1;
  789.                     goto get_next_arg;
  790.  
  791.                 case 's':
  792.                     spprdflt = true;
  793.                     break;
  794.  
  795.                 case 't':
  796.                     use_stdout = true;
  797.                     break;
  798.  
  799.                 case 'T':
  800.                     trace = true;
  801.                     break;
  802.  
  803.                 case 'v':
  804.                     printstats = true;
  805.                     break;
  806.  
  807.                 case 'V':
  808.                     printf( _( "%s version %s\n" ),
  809.                         program_name, flex_version );
  810.                     exit( 0 );
  811.  
  812.                 case 'w':
  813.                     nowarn = true;
  814.                     break;
  815.  
  816.                 case '7':
  817.                     csize = 128;
  818.                     break;
  819.  
  820.                 case '8':
  821.                     csize = CSIZE;
  822.                     break;
  823.  
  824.                 default:
  825.                     fprintf( stderr,
  826.         _( "%s: unknown flag '%c'.  For usage, try\n\t%s --help\n" ),
  827.                         program_name, (int) arg[i],
  828.                         program_name );
  829.                     exit( 1 );
  830.                 }
  831.  
  832.         /* Used by -C, -S, -o, and -P flags in lieu of a "continue 2"
  833.          * control.
  834.          */
  835.         get_next_arg: ;
  836.         }
  837.  
  838.     num_input_files = argc;
  839.     input_files = argv;
  840.     set_input_file( num_input_files > 0 ? input_files[0] : NULL );
  841.  
  842.     lastccl = lastsc = lastdfa = lastnfa = 0;
  843.     num_rules = num_eof_rules = default_rule = 0;
  844.     numas = numsnpairs = tmpuses = 0;
  845.     numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
  846.     numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
  847.     num_backing_up = onesp = numprots = 0;
  848.     variable_trailing_context_rules = bol_needed = false;
  849.  
  850.     out_linenum = linenum = sectnum = 1;
  851.     firstprot = NIL;
  852.  
  853.     /* Used in mkprot() so that the first proto goes in slot 1
  854.      * of the proto queue.
  855.      */
  856.     lastprot = 1;
  857.  
  858.     set_up_initial_allocations();
  859.     }
  860.  
  861.  
  862. /* readin - read in the rules section of the input file(s) */
  863.  
  864. void readin()
  865.     {
  866.     static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
  867.     static char yy_nostdinit[] =
  868.         "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
  869.  
  870.     line_directive_out( (FILE *) 0, 1 );
  871.  
  872.     if ( yyparse() )
  873.         {
  874.         pinpoint_message( _( "fatal parse error" ) );
  875.         flexend( 1 );
  876.         }
  877.  
  878.     if ( syntaxerror )
  879.         flexend( 1 );
  880.  
  881.     if ( backing_up_report )
  882.         {
  883.         backing_up_file = fopen( backing_name, "w" );
  884.         if ( backing_up_file == NULL )
  885.             lerrsf(
  886.             _( "could not create backing-up info file %s" ),
  887.                 backing_name );
  888.         }
  889.  
  890.     else
  891.         backing_up_file = NULL;
  892.  
  893.     if ( yymore_really_used == true )
  894.         yymore_used = true;
  895.     else if ( yymore_really_used == false )
  896.         yymore_used = false;
  897.  
  898.     if ( reject_really_used == true )
  899.         reject = true;
  900.     else if ( reject_really_used == false )
  901.         reject = false;
  902.  
  903.     if ( performance_report > 0 )
  904.         {
  905.         if ( lex_compat )
  906.             {
  907.             fprintf( stderr,
  908. _( "-l AT&T lex compatibility option entails a large performance penalty\n" ) );
  909.             fprintf( stderr,
  910. _( " and may be the actual source of other reported performance penalties\n" ) );
  911.             }
  912.  
  913.         else if ( do_yylineno )
  914.             {
  915.             fprintf( stderr,
  916.     _( "%%option yylineno entails a large performance penalty\n" ) );
  917.             }
  918.  
  919.         if ( performance_report > 1 )
  920.             {
  921.             if ( interactive )
  922.                 fprintf( stderr,
  923.     _( "-I (interactive) entails a minor performance penalty\n" ) );
  924.  
  925.             if ( yymore_used )
  926.                 fprintf( stderr,
  927.         _( "yymore() entails a minor performance penalty\n" ) );
  928.             }
  929.  
  930.         if ( reject )
  931.             fprintf( stderr,
  932.             _( "REJECT entails a large performance penalty\n" ) );
  933.  
  934.         if ( variable_trailing_context_rules )
  935.             fprintf( stderr,
  936. _( "Variable trailing context rules entail a large performance penalty\n" ) );
  937.         }
  938.  
  939.     if ( reject )
  940.         real_reject = true;
  941.  
  942.     if ( variable_trailing_context_rules )
  943.         reject = true;
  944.  
  945.     if ( (fulltbl || fullspd) && reject )
  946.         {
  947.         if ( real_reject )
  948.             flexerror(
  949.                 _( "REJECT cannot be used with -f or -F" ) );
  950.         else if ( do_yylineno )
  951.             flexerror(
  952.             _( "%option yylineno cannot be used with -f or -F" ) );
  953.         else
  954.             flexerror(
  955.     _( "variable trailing context rules cannot be used with -f or -F" ) );
  956.         }
  957.  
  958.     if ( reject )
  959.         outn( "\n#define YY_USES_REJECT" );
  960.  
  961.     if ( ! do_yywrap )
  962.         {
  963.         outn( "\n#define yywrap() 1" );
  964.         outn( "#define YY_SKIP_YYWRAP" );
  965.         }
  966.  
  967.     if ( ddebug )
  968.         outn( "\n#define FLEX_DEBUG" );
  969.  
  970.     if ( csize == 256 )
  971.         outn( "typedef unsigned char YY_CHAR;" );
  972.     else
  973.         outn( "typedef char YY_CHAR;" );
  974.  
  975.     if ( C_plus_plus )
  976.         {
  977.         outn( "#define yytext_ptr yytext" );
  978.  
  979.         if ( interactive )
  980.             outn( "#define YY_INTERACTIVE" );
  981.         }
  982.  
  983.     else
  984.         {
  985.         if ( do_stdinit )
  986.             {
  987.             outn( "#ifdef VMS" );
  988.             outn( "#ifndef __VMS_POSIX" );
  989.             outn( yy_nostdinit );
  990.             outn( "#else" );
  991.             outn( yy_stdinit );
  992.             outn( "#endif" );
  993.             outn( "#else" );
  994.             outn( yy_stdinit );
  995.             outn( "#endif" );
  996.             }
  997.  
  998.         else
  999.             outn( yy_nostdinit );
  1000.         }
  1001.  
  1002.     if ( fullspd )
  1003.         outn( "typedef const struct yy_trans_info *yy_state_type;" );
  1004.     else if ( ! C_plus_plus )
  1005.         outn( "typedef int yy_state_type;" );
  1006.  
  1007.     if ( ddebug )
  1008.         outn( "\n#define FLEX_DEBUG" );
  1009.  
  1010.     if ( lex_compat )
  1011.         outn( "#define YY_FLEX_LEX_COMPAT" );
  1012.  
  1013.     if ( do_yylineno && ! C_plus_plus )
  1014.         {
  1015.         outn( "extern int yylineno;" );
  1016.         outn( "int yylineno = 1;" );
  1017.         }
  1018.  
  1019.     if ( C_plus_plus )
  1020.         {
  1021.         outn( "\n#include <FlexLexer.h>" );
  1022.  
  1023.         if ( yyclass )
  1024.             {
  1025.             outn( "int yyFlexLexer::yylex()" );
  1026.             outn( "\t{" );
  1027.             outn(
  1028. "\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );" );
  1029.             outn( "\treturn 0;" );
  1030.             outn( "\t}" );
  1031.     
  1032.             out_str( "\n#define YY_DECL int %s::yylex()\n",
  1033.                 yyclass );
  1034.             }
  1035.         }
  1036.  
  1037.     else
  1038.         {
  1039.         if ( yytext_is_array )
  1040.             outn( "extern char yytext[];\n" );
  1041.  
  1042.         else
  1043.             {
  1044.             outn( "extern char *yytext;" );
  1045.             outn( "#define yytext_ptr yytext" );
  1046.             }
  1047.  
  1048.         if ( yyclass )
  1049.             flexerror(
  1050.         _( "%option yyclass only meaningful for C++ scanners" ) );
  1051.         }
  1052.  
  1053.     if ( useecs )
  1054.         numecs = cre8ecs( nextecm, ecgroup, csize );
  1055.     else
  1056.         numecs = csize;
  1057.  
  1058.     /* Now map the equivalence class for NUL to its expected place. */
  1059.     ecgroup[0] = ecgroup[csize];
  1060.     NUL_ec = ABS( ecgroup[0] );
  1061.  
  1062.     if ( useecs )
  1063.         ccl2ecl();
  1064.     }
  1065.  
  1066.  
  1067. /* set_up_initial_allocations - allocate memory for internal tables */
  1068.  
  1069. void set_up_initial_allocations()
  1070.     {
  1071.     current_mns = INITIAL_MNS;
  1072.     firstst = allocate_integer_array( current_mns );
  1073.     lastst = allocate_integer_array( current_mns );
  1074.     finalst = allocate_integer_array( current_mns );
  1075.     transchar = allocate_integer_array( current_mns );
  1076.     trans1 = allocate_integer_array( current_mns );
  1077.     trans2 = allocate_integer_array( current_mns );
  1078.     accptnum = allocate_integer_array( current_mns );
  1079.     assoc_rule = allocate_integer_array( current_mns );
  1080.     state_type = allocate_integer_array( current_mns );
  1081.  
  1082.     current_max_rules = INITIAL_MAX_RULES;
  1083.     rule_type = allocate_integer_array( current_max_rules );
  1084.     rule_linenum = allocate_integer_array( current_max_rules );
  1085.     rule_useful = allocate_integer_array( current_max_rules );
  1086.  
  1087.     current_max_scs = INITIAL_MAX_SCS;
  1088.     scset = allocate_integer_array( current_max_scs );
  1089.     scbol = allocate_integer_array( current_max_scs );
  1090.     scxclu = allocate_integer_array( current_max_scs );
  1091.     sceof = allocate_integer_array( current_max_scs );
  1092.     scname = allocate_char_ptr_array( current_max_scs );
  1093.  
  1094.     current_maxccls = INITIAL_MAX_CCLS;
  1095.     cclmap = allocate_integer_array( current_maxccls );
  1096.     ccllen = allocate_integer_array( current_maxccls );
  1097.     cclng = allocate_integer_array( current_maxccls );
  1098.  
  1099.     current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
  1100.     ccltbl = allocate_Character_array( current_max_ccl_tbl_size );
  1101.  
  1102.     current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
  1103.  
  1104.     current_max_xpairs = INITIAL_MAX_XPAIRS;
  1105.     nxt = allocate_integer_array( current_max_xpairs );
  1106.     chk = allocate_integer_array( current_max_xpairs );
  1107.  
  1108.     current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
  1109.     tnxt = allocate_integer_array( current_max_template_xpairs );
  1110.  
  1111.     current_max_dfas = INITIAL_MAX_DFAS;
  1112.     base = allocate_integer_array( current_max_dfas );
  1113.     def = allocate_integer_array( current_max_dfas );
  1114.     dfasiz = allocate_integer_array( current_max_dfas );
  1115.     accsiz = allocate_integer_array( current_max_dfas );
  1116.     dhash = allocate_integer_array( current_max_dfas );
  1117.     dss = allocate_int_ptr_array( current_max_dfas );
  1118.     dfaacc = allocate_dfaacc_union( current_max_dfas );
  1119.  
  1120.     nultrans = (int *) 0;
  1121.     }
  1122.  
  1123.  
  1124. void usage()
  1125.     {
  1126.     FILE *f = stdout;
  1127.  
  1128.     fprintf( f,
  1129. _( "%s [-bcdfhilnpstvwBFILTV78+? -C[aefFmr] -ooutput -Pprefix -Sskeleton]\n" ),
  1130.         program_name );
  1131.     fprintf( f, _( "\t[--help --version] [file ...]\n" ) );
  1132.  
  1133. #ifdef __GIJO__
  1134.     fprintf( f, _( "\t-A  align tables\n" ) );
  1135. #endif
  1136.     fprintf( f, _( "\t-b  generate backing-up information to %s\n" ),
  1137.         backing_name );
  1138.     fprintf( f, _( "\t-c  do-nothing POSIX option\n" ) );
  1139.     fprintf( f, _( "\t-d  turn on debug mode in generated scanner\n" ) );
  1140.     fprintf( f, _( "\t-f  generate fast, large scanner\n" ) );
  1141.     fprintf( f, _( "\t-h  produce this help message\n" ) );
  1142.     fprintf( f, _( "\t-i  generate case-insensitive scanner\n" ) );
  1143.     fprintf( f, _( "\t-l  maximal compatibility with original lex\n" ) );
  1144.     fprintf( f, _( "\t-n  do-nothing POSIX option\n" ) );
  1145.     fprintf( f, _( "\t-p  generate performance report to stderr\n" ) );
  1146. #ifdef __GIJO__
  1147.     fprintf( f, _( "\t-R  use read() instead of stdio for scanner input\n" ) );
  1148. #endif
  1149.     fprintf( f,
  1150.         _( "\t-s  suppress default rule to ECHO unmatched text\n" ) );
  1151.  
  1152.     if ( ! did_outfilename )
  1153.         {
  1154.         sprintf( outfile_path, outfile_template,
  1155.             prefix, C_plus_plus ? "cc" : "c" );
  1156.         outfilename = outfile_path;
  1157.         }
  1158.  
  1159.     fprintf( f,
  1160.         _( "\t-t  write generated scanner on stdout instead of %s\n" ),
  1161.         outfilename );
  1162.  
  1163.     fprintf( f,
  1164.         _( "\t-v  write summary of scanner statistics to f\n" ) );
  1165.     fprintf( f, _( "\t-w  do not generate warnings\n" ) );
  1166.     fprintf( f, _( "\t-B  generate batch scanner (opposite of -I)\n" ) );
  1167.     fprintf( f,
  1168.         _( "\t-F  use alternative fast scanner representation\n" ) );
  1169.     fprintf( f,
  1170.         _( "\t-I  generate interactive scanner (opposite of -B)\n" ) );
  1171.     fprintf( f, _( "\t-L  suppress #line directives in scanner\n" ) );
  1172.     fprintf( f, _( "\t-T  %s should run in trace mode\n" ), program_name );
  1173.     fprintf( f, _( "\t-V  report %s version\n" ), program_name );
  1174.     fprintf( f, _( "\t-7  generate 7-bit scanner\n" ) );
  1175.     fprintf( f, _( "\t-8  generate 8-bit scanner\n" ) );
  1176.     fprintf( f, _( "\t-+  generate C++ scanner class\n" ) );
  1177.     fprintf( f, _( "\t-?  produce this help message\n" ) );
  1178.     fprintf( f,
  1179. _( "\t-C  specify degree of table compression (default is -Cem):\n" ) );
  1180.     fprintf( f,
  1181. _( "\t\t-Ca  trade off larger tables for better memory alignment\n" ) );
  1182.     fprintf( f, _( "\t\t-Ce  construct equivalence classes\n" ) );
  1183.     fprintf( f,
  1184. _( "\t\t-Cf  do not compress scanner tables; use -f representation\n" ) );
  1185.     fprintf( f,
  1186. _( "\t\t-CF  do not compress scanner tables; use -F representation\n" ) );
  1187.     fprintf( f, _( "\t\t-Cm  construct meta-equivalence classes\n" ) );
  1188.     fprintf( f,
  1189.     _( "\t\t-Cr  use read() instead of stdio for scanner input\n" ) );
  1190.     fprintf( f, _( "\t-o  specify output filename\n" ) );
  1191.     fprintf( f, _( "\t-P  specify scanner prefix other than \"yy\"\n" ) );
  1192.     fprintf( f, _( "\t-S  specify skeleton file\n" ) );
  1193.     fprintf( f, _( "\t--help     produce this help message\n" ) );
  1194.     fprintf( f, _( "\t--version  report %s version\n" ), program_name );
  1195.     }
  1196.